import {AbstractControl, FormControl, ValidatorFn} from "@angular/forms";
import {Observable, of} from "rxjs/index";
import {CommService} from "./comm-service";
import {Injectable} from "@angular/core";


declare var $: any;

@Injectable({
  providedIn: "root"
})

export class MyValidator {

  euqalValidator(newpwdCtr: FormControl): ValidatorFn {
    return (rnewpswCtr: AbstractControl): { [key: string]: any } => {
      let valid: boolean = (rnewpswCtr.value === newpwdCtr.value);
      if (!valid) {
        return {
          equal: {
            msg: "密码和确认密码不匹配"
          }
        }
      } else {
        return null;
      }
    }
  }

  bigTime(btimeCtr: FormControl): ValidatorFn {
    return (etimeCtr: AbstractControl): { [key: string]: any } => {
      const btimev = btimeCtr.value;
      const etiemV = etimeCtr.value;
      const valid = new Date(etiemV).getTime() - new Date(btimev).getTime() > 0;
      if (!valid) {
        return {
          notbig: {
            msg: "结束时间必须大于开始时间"
          }
        }
      } else {
        return null;
      }
    }
  }

  asynValidator(): ValidatorFn {
    return (ctr: AbstractControl): Observable<any> => {
      let isvalid: boolean = false;
      $.ajax({
        url: "xxzx_client/jgxx/selectLowerJGBH",
        type: "get",
        async: false,
        data: {
          token: this.commservice.getToken()
        },
        dataType: "json",
        contentType: "application/x-www-form-urlencoded",
        success: function (resp) {
          const retflag = resp.result;
          const rows = resp.rows;
          if (retflag == "success") {
            if (rows.indexOf(ctr.value) != -1) {
              isvalid = true;
            }
          }
        }
      });
      return isvalid ? of({
        isExist: {
          msg: "该编码已经存在"
        }
      }) : of(null);
    }
  }

  isABC(b: boolean): ValidatorFn {
    return (ctr: AbstractControl): { [key: string]: any } => {
      const regext = /^[a-zA-Z_]\w+$/;
      const itv = ctr.value ? ctr.value.toString().trim() : "";
      if (b) {
        if (!regext.test(itv)) {
          return {
            abc: {
              msg: "字母开头的字符串"
            }
          }
        } else {
          return null;
        }
      } else {
        if (itv) {
          if (!regext.test(itv)) {
            return {
              abc: {
                msg: "字母开头的字符串"
              }
            }
          } else {
            return null;
          }
        } else {
          return null;
        }
      }
    }
  }

  isNumber(b: boolean): ValidatorFn {
    return (ctr: AbstractControl): { [key: string]: any } => {
      const regex = /^[1-9]\d*$/; //正整数
      const itv = ctr.value ? ctr.value.toString().trim() : "";
      if (b) {
        if (!regex.test(itv)) {
          return {
            number: {
              msg: "只能是正整数"
            }
          }
        } else {
          return null;
        }
      } else {
        if (itv) {
          if (!regex.test(itv)) {
            return {
              number: {
                msg: "只能是正整数"
              }
            }
          } else {
            return null;
          }
        } else {
          return null;
        }
      }
    }
  }

  isNumberMax(b: boolean, maxv: number): ValidatorFn {
    return (ctr: AbstractControl): { [key: string]: any } => {
      const regex = /^[1-9]\d*$/; //正整数
      const itv = ctr.value ? ctr.value.toString().trim() : "";
      if (b) {
        if (!regex.test(itv)) {
          return {
            numbermax: {
              msg: "只能是数字"
            }
          }
        } else {
          if (Number(itv) > maxv) {
            return {
              numbermax: {
                msg: `1到${maxv}之间的数字`
              }
            }
          } else {
            return null;
          }
        }
      } else {
        if (itv) {
          if (!regex.test(itv)) {
            return {
              numbermax: {
                msg: "只能是数字"
              }
            }
          } else {
            if (Number(itv) > maxv) {
              return {
                numbermax: {
                  msg: `1到${maxv}之间的数字`
                }
              }
            } else {
              return null;
            }
          }
        } else {
          return null;
        }
      }
    }
  }

  isNumberLh(b: boolean, maxv: number): ValidatorFn {
    return (ctr: AbstractControl): { [key: string]: any } => {
      const regex = /^[1-9]\d*$/; //正整数
      const itv = ctr.value ? ctr.value.toString().trim() : "";
      if (b) {
        if (!regex.test(itv)) {
          return {
            numbermax: {
              msg: "只能是数字"
            }
          }
        } else {
          if (Number(itv.length) > maxv) {
            return {
              numbermax: {
                msg: `必须为14位准考证号`
              }
            }
          } else if (Number(itv.length) < maxv) {
            return {
              numbermax: {
                msg: `必须为14位准考证号`
              }
            }
          } else {
            return null;
          }
        }
      } else {
        if (itv) {
          if (!regex.test(itv)) {
            return {
              numbermax: {
                msg: "只能是数字"
              }
            }
          } else {
            if (Number(itv.length) > maxv) {
              return {
                numbermax: {
                  msg: `必须为14位准考证号`
                }
              }
            } else if (Number(itv.length) < maxv) {
              return {
                numbermax: {
                  msg: `必须为14位准考证号`
                }
              }
            } else {
              return null;
            }
          }
        } else {
          return null;
        }
      }
    }
  }

  numberLh(b: boolean, maxv: number): ValidatorFn {
    return (ctr: AbstractControl): { [key: string]: any } => {
      const regex = /^\d{10,}$/;
      const itv = ctr.value ? ctr.value.toString().trim() : "";
      if (b) {
        if (!regex.test(itv)) {
          return {
            numbermax: {
              msg: "只能是数字且长度不小于10位"
            }
          }
        } else {
          if (Number(itv.length) < maxv) {
            return {
              numbermax: {
                msg: `准考证号有误`
              }
            }
          } else {
            return null;
          }
        }
      } else {
        if (itv) {
          if (!regex.test(itv)) {
            return {
              numbermax: {
                msg: "只能是数字且长度不小于10位"
              }
            }
          } else {
            if (Number(itv.length) < maxv) {
              return {
                numbermax: {
                  msg: `准考证号有误`
                }
              }
            } else {
              return null;
            }
          }
        } else {
          return null;
        }
      }
    }
  }

  /**
   * 匹配整数（正整数+负整数）+ 0
   * @param {boolean} b
   * @param {number} maxv
   * @returns {ValidatorFn}
   */
  isNumberRange(b: boolean, minv: number, maxv: number): ValidatorFn {
    return (ctr: AbstractControl): { [key: string]: any } => {
      const regex = /^-?[1-9]\d*|0$/; //正整数
      const itv = ctr.value;
      if (b) {
        if (!regex.test(itv)) {
          return {
            numberrange: {
              msg: "只能是数字"
            }
          }
        } else {
          if (Number(itv) > maxv || Number(itv) < minv) {
            return {
              numberrange: {
                msg: `${minv}到${maxv}之间的数字`
              }
            }
          } else {
            return null;
          }
        }
      } else {
        if (itv) {
          if (!regex.test(itv)) {
            return {
              numberrange: {
                msg: "只能是数字"
              }
            }
          } else {
            if (Number(itv) > maxv || Number(itv) < minv) {
              return {
                numberrange: {
                  msg: `${minv}到${maxv}之间的数字`
                }
              }
            } else {
              return null;
            }
          }
        } else {
          return null;
        }
      }
    }
  }


  selecthas(): ValidatorFn {
    return (ctr: AbstractControl): { [key: string]: any } => {
      let vaild = false;
      if (ctr.value.toString().trim() != "") {
        vaild = true;
      }
      if (!vaild) {
        return {
          snone: {
            msg: "是必选项目"
          }
        }
      } else {
        return null;
      }
    }
  }


  /**
   * 手机号验证
   * @param {boolean} b true---必填，且满足      false--非必填，但是填了就要满足
   * @returns {ValidatorFn}
   */
  isMobile(b: boolean): ValidatorFn {
    return (ctr: AbstractControl): { [key: string]: any } => {
      const regex = /^(13[0-9]|14[579]|15[0-3,5-9]|16[6]|17[0135678]|18[0-9]|19[89])\d{8}$/;
      //const ismobileregex = /^1[3|4|5|7|8][0-9]{9}$/;
      const itv = ctr.value ? ctr.value.toString().trim() : "";
      if (b) {
        const valid = regex.test(itv);
        if (!valid) {
          return {
            ismobile: {
              msg: "无效的手机号码"
            }
          }
        } else {
          return null;
        }
      } else {
        if (itv) {
          const valid = regex.test(itv);
          if (!valid) {
            return {
              ismobile: {
                msg: "无效的手机号码"
              }
            }
          } else {
            return null;
          }
        } else {
          return null;
        }
      }
    }
  }

  /**
   * 固定电话验证
   * @param {boolean} b
   * @returns {ValidatorFn}
   */
  isgdDH(b: boolean): ValidatorFn {
    return (ctr: AbstractControl): { [key: string]: any } => {
      //“0”表示以0开头的区号，后面跟2-3位，电话号码7-8位；“-”表示用户在符合条件处可以输入“-”；“\d”表示纯数字；“$”表示结束。
      //const regex = /^0\d{2,3}-?\d{7,8}$/;
      const regex = /^0\d{2,3}-\d{7,8}$/;
      const itv = ctr.value ? ctr.value.toString().trim() : "";
      if (b) {
        const valid = regex.test(itv);
        if (!valid) {
          return {
            isgddh: {
              msg: "无效的固定电话"
            }
          }
        } else {
          return null;
        }
      } else {
        if (itv) {
          const valid = regex.test(itv);
          if (!valid) {
            return {
              isgddh: {
                msg: "无效的固定电话"
              }
            }
          } else {
            return null;
          }
        } else {
          return null;
        }
      }
    }
  }

  /**
   * 联系电话 (手机号 + 固定电话)
   * @param {boolean} b       true---必填，且满足      false--非必填，但是填了就要满足
   * @returns {ValidatorFn}
   */
  islxdh(b: boolean): ValidatorFn {
    return (ctr: AbstractControl): { [key: string]: any } => {
      const itv = ctr.value ? ctr.value.toString().trim() : "";
      const regex = /^(13[0-9]|14[579]|15[0-3,5-9]|16[6]|17[0135678]|18[0-9]|19[89])\d{8}$/;
      const regex2 = /^0\d{2,3}-\d{7,8}$/;
      if (b) {
        if (!regex.test(itv) && !regex2.test(itv)) {
          return {
            islxdh: {
              msg: "无效的联系电话"
            }
          }
        } else {
          return null;
        }
      } else {
        if (itv) {
          if (!regex.test(itv) && !regex2.test(itv)) {
            return {
              islxdh: {
                msg: "无效的联系电话"
              }
            }
          } else {
            return null;
          }
        } else {
          return null;
        }
      }
    }
  }

  isemail(b: boolean): ValidatorFn {
    return (ctr: AbstractControl): { [key: string]: any } => {
      const itv = ctr.value ? ctr.value.toString().trim() : "";
      const regex = /^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$/;
      //const emailregex = /("^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$")/;
      if (b) {
        if (!regex.test(itv.toString().trim())) {
          return {
            isemail: {
              msg: "无效的电子邮件"
            }
          }
        } else {
          return null;
        }
      } else {
        if (itv) {
          if (!regex.test(itv.toString().trim())) {
            return {
              isemail: {
                msg: "无效的电子邮件"
              }
            }
          } else {
            return null;
          }
        } else {
          return null;
        }
      }
    }
  }


  numMatchlx(sfzjlxCtr: FormControl): ValidatorFn {
    return (sfzjnumCtr: AbstractControl): { [key: string]: any } => {
      const sfzjlx = sfzjlxCtr.value;
      let regex: any;
      let errmsg: string = "";
      if (sfzjlx == 1) {
        // 身份证号码为15位或者18位，15位时全为数字，18位前17位为数字，最后一位是校验位，可能为数字或字符X 或者x
        regex = /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/;
        errmsg = "身份证号码不合法";
      } else if (sfzjlx == 2) {
        //军官证
        regex = /^[a-zA-Z0-9]{7,21}$/;
        errmsg = "军官证号不合法";
      } else if (sfzjlx == 3) {
        //士兵证
        regex = /$/;
        errmsg = "士兵证号不合法";
      } else if (sfzjlx == 4) {
        //文职干部证
        regex = /$/;
        errmsg = "文职干部证号不合法";
      } else if (sfzjlx == 5) {
        //部队离退休证
        regex = /$/;
        errmsg = "部队离退休证号不合法";
      } else if (sfzjlx == 6) {
        //香港特区护照/身份证明
        regex = /^[a-zA-Z0-9]{5,21}$/;
        errmsg = "香港特区护照/身份证明号不合法";
      } else if (sfzjlx == 7) {
        //澳门特区护照/身份证明
        regex = /^[a-zA-Z0-9]{5,21}$/;
        errmsg = "澳门特区护照/身份证明号不合法";
      } else if (sfzjlx == 8) {
        //台湾居民来往大陆通行证
        regex = /$/;
        errmsg = "台湾居民来往大陆通行证号不合法";
      } else if (sfzjlx == 9) {
        //境外永久居住证
        regex = /$/;
        errmsg = "境外永久居住号不合法";
      } else if (sfzjlx == "A") {
        //护照
        regex = /^[a-zA-Z0-9]{3,21}$/;
        errmsg = "护照不合法";
      } else if (sfzjlx == "B") {
        //户口薄
        regex = /$/;
        errmsg = "户口薄号不合法";
      } else if (sfzjlx == "Z") {
        //其他证件类型
        regex = /$/;
      } else {
        regex = /$/;
      }
      const vaild = regex.test(sfzjnumCtr.value);
      if (!vaild) {
        return {
          numMatchlx: {
            msg: errmsg
          }
        }
      } else {
        return null;
      }
    }
  }

  /**
   * 身份证件的验证
   * @param {boolean} b
   * @returns {ValidatorFn}
   */
  isSfzCard(b: boolean): ValidatorFn {
    return (ctr: AbstractControl): { [key: string]: any } => {
      const card = ctr.value ? ctr.value.toString().trim() : "";
      // 身份证号码为15位或者18位，15位时全为数字，18位前17位为数字，最后一位是校验位，可能为数字或字符X 或者x
      const regex = /(^\d{15}$)|(^\d{18}$)|(^\d{17}(\d|X|x)$)/;
      if (b) {
        if (!regex.test(card)) {
          return {
            isCard: {
              msg: "身份证件号码不正确"
            }
          }
        } else {
          return null;
        }
      } else {
        if (card) {
          if (!regex.test(card)) {
            return {
              isCard: {
                msg: "身份证件号码不正确"
              }
            }
          } else {
            return null;
          }
        } else {
          return null;
        }
      }
    }
  }

  isAmount(b: boolean): ValidatorFn {
    return (ctr: AbstractControl): { [key: string]: any } => {
      const itv = ctr.value ? ctr.value.toString().trim() : "";
      const regex = /^[1-9]\d*$/;
      if (b) {
        if (!regex.test(itv)) {
          return {
            isAmount: {
              msg: "数量是非0开头的正整数"
            }
          }
        } else {
          if (itv.length > 8) {
            return {
              isAmount: {
                msg: "数量过大"
              }
            }
          } else {
            return null;
          }
        }
      } else {
        if (itv) {
          if (!regex.test(itv)) {
            return {
              isAmount: {
                msg: "数量是非0开头的正整数"
              }
            }
          } else {
            if (itv.length > 8) {
              return {
                isAmount: {
                  msg: "数量过大"
                }
              }
            } else {
              return null;
            }
          }
        } else {
          return null;
        }
      }
    }
  }

  limitLen(min: number, max: number, b: boolean): ValidatorFn {
    return (ctr: AbstractControl): { [key: string]: any } => {
      const itv = ctr.value ? ctr.value.toString().trim() : "";
      if (b) {
        const itlength = itv.length;
        if (itlength < min || itlength > max) {
          return {
            limit: {
              msg: "长度在" + min + "到" + max + "个字符"
            }
          }
        } else {
          return null;
        }
      } else {
        if (itv) {
          const itlength = itv.length;
          if (itlength < min || itlength > max) {
            return {
              limit: {
                msg: "长度在" + min + "到" + max + "个字符"
              }
            }
          } else {
            return null;
          }
        } else {
          return null;
        }
      }
    }
  }

  numRange(min: number, max: number, b: boolean): ValidatorFn {
    return (ctr: AbstractControl): { [key: string]: any } => {
      const itv = ctr.value ? ctr.value.toString().trim() : "";
      const regex = /^[1-9]\d*$/; //正整数
      if (b) {
        if (!regex.test(itv) || itv > 100) {
          return {
            numRangeErr: {
              msg: "输入" + min + "到" + max + "之间的正整数"
            }
          }
        } else {
          return null;
        }
      } else {
        if (itv) {
          if (!regex.test(itv) || itv > 100) {
            return {
              numRangeErr: {
                msg: "输入" + min + "到" + max + "之间的正整数"
              }
            }
          } else {
            return null;
          }
        } else {
          return null;
        }
      }
    }
  }

  limitOnenum(b: boolean): ValidatorFn {
    return (ctr: AbstractControl): { [key: string]: any } => {
      const itv = ctr.value ? ctr.value.toString().trim() : "";
      const regex = /^([1-9])$/;
      if (b) {
        if (!regex.test(itv) || itv.toString().length != 1) {
          return {
            limitOnenum: {
              msg: "只能输入1位正整数"
            }
          }
        } else {
          return null;
        }
      } else {
        if (itv) {
          if (!regex.test(itv) || itv.toString().length != 1) {
            return {
              limitOnenum: {
                msg: "只能输入1位正整数"
              }
            }
          } else {
            return null;
          }
        } else {
          return null;
        }
      }
    }
  }

  limitTwonum(b: boolean): ValidatorFn {
    return (ctr: AbstractControl): { [key: string]: any } => {
      const itv = ctr.value ? ctr.value.toString().trim() : "";
      const regex = /^\+?[0-9][0-9]*$/; //非0正整数
      if (b) {
        if (itv) {
          if (!regex.test(itv) || itv.toString().length != 2) {
            return {
              limitTwonum: {
                msg: "只能是2位数字"
              }
            }
          } else {
            return null;
          }
        } else {
          return null;
        }
      } else {
        if (!regex.test(itv) || itv.toString().length != 2) {
          return {
            limitTwonum: {
              msg: "只能是2位数字"
            }
          }
        } else {
          return null;
        }
      }
    }
  }

  isIp(b: boolean): ValidatorFn {
    return (ctr: AbstractControl): { [key: string]: any } => {
      const itv = ctr.value ? ctr.value.toString().trim() : "";
      const regex = /^(?:(?:2[0-4][0-9]\.)|(?:25[0-5]\.)|(?:1[0-9][0-9]\.)|(?:[1-9][0-9]\.)|(?:[0-9]\.)){3}(?:(?:2[0-5][0-5])|(?:25[0-5])|(?:1[0-9][0-9])|(?:[1-9][0-9])|(?:[0-9]))$/;
      if (b) {
        if (!regex.test(itv)) {
          return {
            isIp: {
              msg: "IP地址格式错误"
            }
          }
        } else {
          return null;
        }
      } else {
        if (itv) {
          if (!regex.test(itv)) {
            return {
              isIp: {
                msg: "IP地址格式错误"
              }
            }
          } else {
            return null;
          }
        } else {
          return null;
        }
      }
    }
  }

  isMac(b: boolean): ValidatorFn {
    return (ctr: AbstractControl): { [key: string]: any } => {
      const itv = ctr.value ? ctr.value.toString().trim() : "";
      // const regex = /^[A-F0-9]{2}(-[A-F0-9]{2}){5}$/;
      const regex = /^[a-fA-F0-9]{2}(:[a-fA-F0-9]{2}){5}$/;
      if (b) {
        if (!regex.test(itv)) {
          return {
            isMac: {
              msg: "MAC地址格式或者大小写错误"
            }
          }
        } else {
          return null;
        }
      } else {
        if (itv) {
          if (!regex.test(itv)) {
            return {
              isMac: {
                msg: "MAC地址格式或者大小写错误"
              }
            }
          } else {
            return null;
          }
        } else {
          return null;
        }
      }
    }
  }

  /**
   * 字母开头，字母+数字  4-10
   * @param {boolean} b
   * @returns {ValidatorFn}
   */
  letter_number(b: boolean): ValidatorFn {
    return (ctr: AbstractControl): { [key: string]: any } => {
      const itv = ctr.value ? ctr.value.toString().trim() : "";
      const regex = /^[a-zA-Z0-9\u4e00-\u9fa5]{3,9}$/;
      if (b) {
        if (!regex.test(itv)) {
          return {
            isLetterandnum: {
              msg: "汉字数字加字母的4到10个字符"
            }
          }
        } else {
          return null;
        }
      } else {
        if (itv) {
          if (!regex.test(itv)) {
            return {
              isLetterandnum: {
                msg: "汉字数字加字母的4到10个字符"
              }
            }
          } else {
            return null;
          }
        } else {
          return null;
        }
      }
    }
  }

  /**
   *
   * @returns {ValidatorFn}
   */
  isPort(b: boolean): ValidatorFn {
    return (ctr: AbstractControl): { [key: string]: any } => {
      const itv = ctr.value ? ctr.value.toString().trim() : "";
      const regext = /^[1-9]\d*$/;
      if (b) {
        if (!regext.test(itv)) {
          return {
            isPort: {
              msg: "端口号格式错误"
            }
          }
        } else {
          if (itv < 1 || itv > 65535) {
            return {
              isPort: {
                msg: "端口号格式错误"
              }
            }
          } else {
            return null;
          }
        }
      } else {
        if (itv) {
          if (!regext.test(itv)) {
            return {
              isPort: {
                msg: "端口号格式错误"
              }
            }
          } else {
            if (itv < 1 || itv > 65535) {
              return {
                isPort: {
                  msg: "端口号格式错误"
                }
              }
            } else {
              return null;
            }
          }
        } else {
          return null;
        }
      }
    }
  }

  linitlen(b: boolean, num: number): ValidatorFn {
    return (ctr: AbstractControl): { [key: string]: any } => {
      const itv = ctr.value ? ctr.value.toString().trim() : "";
      if (b) {
        if (!itv) {
          return {
            outlength: {
              msg: "必填"
            }
          }
        } else {
          if (itv.length > num) {
            return {
              outlength: {
                msg: "限制在" + num + "以内"
              }
            }
          } else {
            return null;
          }
        }
      } else {
        if (itv) {
          if (itv.length > num) {
            return {
              outlength: {
                msg: "限制在" + num + "以内"
              }
            }
          } else {
            return null;
          }
        } else {
          return null;
        }
      }
    }
  }

  myrequired(labelname: string): ValidatorFn {
    return (ctr: AbstractControl): { [key: string]: any } => {
      const itv = ctr.value ? ctr.value.toString().trim() : "";
      if (!itv) {
        return {
          myrequire: {
            msg: labelname + "必填"
          }
        }
      } else {
        return null;
      }
    }
  }

  mb_mbzd_ywm(b: boolean): ValidatorFn {
    const reg = /^[a-zA-Z][a-zA-Z0_]{1,24}$/;
    return (ctr: AbstractControl): { [key: string]: any } => {
      const itv = ctr.value ? ctr.value.toString().trim() : "";
      if (b) {
        if (!reg.test(itv)) {
          return {
            mbyz: {
              msg: "字母开头，字母加下划线1-24位"
            }
          }
        } else {
          return null
        }
      } else {
        if (itv) {
          if (!reg.test(itv)) {
            return {
              mbyz: {
                msg: "字母开头，字母加下划线1-24位"
              }
            }
          } else {
            return null;
          }
        } else {
          return null;
        }
      }
    }
  }

  /**
   * 码表和码表字段的正则验证
   * @returns {boolean}
   */
  mb_mbzd_ywmZdy(v: string): boolean {
    const reg = /^[a-zA-Z][a-zA-Z0_]{1,24}$/;
    const testv = v.trim();
    return reg.test(testv)
  }

  /**
   * 必填验证
   * @param {string} v
   * @returns {boolean}
   */
  myrequiredZdy(v: string): boolean {
    return v.trim() != "";
  }

  /**
   * 正整数（不包括0）验证
   * @param {string} v
   * @returns {boolean}
   */
  isZzs(v: string): boolean {
    const regex = /^[1-9]\d*$/; //正整数
    return regex.test(v.trim());
  }

  /**
   * 匹配自然数
   * @param {string} v
   * @returns {boolean}
   */
  isZrs(v: string): boolean {
    const regex = /^[+]{0,1}(\d+)$/; //自然数
    return regex.test(v.trim());
  }

  constructor(private commservice: CommService) {

  }
}
